package com.rem.designPattern.designPrinciple.liskovSubstitution;

/**
 * 设计模式七大原则--里氏替换
 * 子类中尽量不要重写父类的方法
 * 继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖 来解决问题
 * <p>
 * 需求：每个类有不同的计算方法，实现各个类的计算
 * <p>
 * 反例：继承之后 误操作导致结果错误
 *
 * @author Rem
 * @date 2022-11-12
 */
public class Liskov01 {
    public static void main(String[] args) {
        System.out.println("-----------a 正常运算------------");
        A a = new A();
        System.out.println("11-3=" + a.func1(11, 3));
        System.out.println("1-8=" + a.func1(1, 8));

        System.out.println("----------B继承A 实现A的所有方法后误操作-------------");
        B b = new B();
        //这里本意是求出A的fun1方法 11-3
        System.err.println("fun1: 本意是求出 11-3: " + b.func1(11, 3));
        //求解两数之和与9相加
        System.out.println("11+3+9= " + b.func2(11, 3));
    }
}

class A {
    /**
     * 返回两个数的差
     *
     * @param num1
     * @param num2
     * @return
     */
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}

/**
 * 增加了一个新功能：完成两个数相加,然后和 9 求和
 */
class B extends A {
    /**
     * 这里，重写了 A 类的方法,  可能是无意识
     *
     * @param a
     * @param b
     * @return
     */
    @Override
    public int func1(int a, int b) {
        return a + b;
    }

    /**
     * B类自己需要的方法 两个数之和与9相加
     *
     * @param a
     * @param b
     * @return
     */
    public int func2(int a, int b) {
        return func1(a, b) + 9;
    }
}